ADA Programming Guide/ADA Programming Guide.iso/ada_lrm/chapd.doc

Text File | 1996-01-30 | 21KB | 860 lines

The following document is a draft  of  the  corresponding  chapter  of  the
version  of  the  Ada  Reference  Manual  produced  in response to the Ansi
Canvass.  It is given a limited circulation  to  Ada  implementers  and  to
other groups contributing comments (according to the conventions defined in
RRM.comments).  This draft should not be referred to in any publication.



                       ANSI-RM-D-v23 - Draft Chapter

                                D Glossary
                                version 23


                                 83-03-11

           This revision has considered all comments up to #5795






















































                                D. Glossary



This  appendix is informative and is not part of the standard definition of
the  Ada  programming  language.   Italicized  terms  in  the   abbreviated
descriptions below either have glossary entries themselves or are described
in entries for related terms.

Accept statement.  See entry.

Access  type.  A value of an access type (an access value) is either a null
value, or a value that designates an object created by an  allocator.   The
designated  object  can  be  read  and  updated  via the access value.  The
definition of an access type specifies the type of the  objects  designated
by values of the access type.  See also collection.

Actual parameter.  See parameter.

Aggregate.   The  evaluation  of an aggregate yields a value of a composite
type.  The  value  is  specified  by  giving  the  value  of  each  of  the
components.  Either positional association or named association may be used
to indicate which value is associated with which component.

Allocator.   The evaluation of an allocator creates an object and returns a
new access value which designates the object.

Array type.  A value of an array type consists of components which are  all
of  the  same  subtype  (and  hence,  of the same type).  Each component is
uniquely distinguished by an index (for a one-dimensional array)  or  by  a
sequence  of  indices (for a multidimensional array).  Each index must be a
value of a discrete type and must lie in the correct index range.

Assignment.  Assignment is the operation that replaces the current value of
a variable by a new value.  An assignment statement specifies a variable on
the left, and on the right, an expression whose value  is  to  be  the  new
value of the variable.

Attribute.    The   evaluation   of   an   attribute  yields  a  predefined
characteristic of a named entity;  some attributes are functions.

Block statement.  A block statement is a single statement that may  contain
a  sequence  of  statements.   It  may also include a declarative part, and
exception handlers;  their effects are local to the block statement.

Body.  A body defines the execution of a subprogram, package, or  task.   A
body  stub  is a form of body that indicates that this execution is defined
in a separately compiled subunit.




                                   D - 1








Collection.   A  collection  is  the  entire  set  of  objects  created  by
evaluation of allocators for an access type.

Compilation  unit.   A compilation unit is the declaration or the body of a
program unit, presented for compilation as  an  independent  text.   It  is
optionally  preceded  by  a  context clause, naming other compilation units
upon which it depends by means of one more with clauses.

Component.  A component is a value that is a part of a larger value, or  an
object that is part of a larger object.















































                                   D - 2








Composite  type.   A  composite  type  is one whose values have components.
There are two kinds of composite type:  array types and record types.

Constant.  See object.

Constraint.  A constraint determines a subset of the values of a  type.   A
value in that subset satisfies the constraint.

Context clause.  See compilation unit.

Declaration.   A  declaration  associates  an  identifier  (or  some  other
notation) with an entity.  This association is in effect within a region of
text  called  the  scope  of  the  declaration.   Within  the  scope  of  a
declaration, there are places where it is possible to use the identifier to
refer  to the associated declared entity.  At such places the identifier is
said to be a simple name of the entity;  the name is  said  to  denote  the
associated entity.

Declarative  Part.   A  declarative part is a sequence of declarations.  It
may  also  contain  related  information  such  as  subprogram  bodies  and
representation clauses.

Denote.  See declaration.

Derived  Type.   A  derived  type is a type whose operations and values are
replicas of those of an existing type.  The existing  type  is  called  the
parent type of the derived type.

Designate.  See access type, task.

Direct visibility.  See visibility.

Discrete  Type.   A  discrete  type  is  a type which has an ordered set of
distinct values.  The discrete types are the enumeration and integer types.
Discrete types are used for indexing and iteration, and for choices in case
statements and record variants.

Discriminant.  A discriminant is a distinguished component of an object  or
value  of  a  record type.  The subtypes of other components, or even their
presence or absence, may depend on the value of the discriminant.

Discriminant constraint.  A discriminant constraint on  a  record  type  or
private type specifies a value for each discriminant of the type.

Elaboration.   The elaboration of a declaration is the process by which the
declaration achieves its effect (such as creating an object);  this process
occurs during program execution.

Entry.  An entry is used for communication between tasks.  Externally,   an
entry  is  called just as a subprogram is called;  its internal behavior is
specified by one or more accept statements specifying  the  actions  to  be
performed when the entry is called.

Enumeration type.  An enumeration type is a discrete  type whose values are
represented  by enumeration literals which are given explicitly in the type


                                   D - 3








declaration.   These  enumeration  literals  are  either   identifiers   or
character literals.

Evaluation.   The  evaluation  of an expression is the process by which the
value of the expression is computed.  This process  occurs  during  program
execution.

Exception.   An  exception  is  an  error  situation which may arise during
program execution.  To raise an exception  is  to  abandon  normal  program
execution  so  as  to  signal that the error has taken place.  An exception
handler is  a  portion  of  program  text  specifying  a  response  to  the
exception.   Execution  of  such  a  program  text  is  called handling the
exception.












































                                   D - 4








Expanded name.  An expanded  name  denotes  an  entity  which  is  declared
immediately  within  some  construct.   An  expanded name has the form of a
selected component:  the prefix denotes the construct (a program unit;   or
a  block,  loop,  or accept statement);  the selector is the simple name of
the entity.

Expression.  An expression defines the computation of a value.

Fixed point type.  See real type.

Floating point type.  See real type.

Formal parameter.  See parameter.

Function.  See subprogram.

Generic unit.  A generic unit is a template either for a set of subprograms
or for a set of packages.   A  subprogram  or  package  created  using  the
template   is   called   an  instance  of  the  generic  unit.   A  generic
instantiation is the kind of  declaration  that  creates  an  instance.   A
generic   unit  is  written  as  a  subprogram  or  package  but  with  the
specification prefixed by a generic formal part which may  declare  generic
formal  parameters.   A  generic  formal  parameter  is  either  a  type, a
subprogram, or an object.  A generic unit is one of the  kinds  of  program
unit.

Handler.  See exception.

Index.  See array type.

Index  constraint.   An  index  constraint  for an array type specifies the
lower and upper bounds for each index range of the array type.

Indexed component.  An indexed component denotes a component in  an  array.
It is a form of name containing expressions which specify the values of the
indices  of  the  array component.  An indexed component may also denote an
entry in a family of entries.

Instance.  See generic unit.

Integer type.  An integer type is a discrete type  whose  values  represent
all integer numbers within a specific range.

Lexical  element.   A  lexical  element  is  an  identifier,  a  literal, a
delimiter, or a comment.

Limited type.  A limited type is a type for which  neither  assignment  nor
the  predefined  comparison  for equality is implicitly declared.  All task
types are limited.  A private type  can  be  defined  to  be  limited.   An
equality operator can be explicitly declared for a limited type.

Literal.     A  literal  represents a value literally, that is, by means of
letters and other characters.  A literal is either a  numeric  literal,  an
enumeration literal, a character literal, or a string literal.



                                   D - 5








Mode.  See parameter.

Model  number.   A model number is an exactly representable value of a real
type.  Operations of a real type are defined in terms of operations on  the
model  numbers  of  the  type.   The properties of the model numbers and of
their  operations   are   the   minimal   properties   preserved   by   all
implementations of the real type.

Name.   A  name  is a construct that stands for an entity:  it is said that
the name denotes the entity, and that the entity  is  the  meaning  of  the
name.  See also declaration, prefix.














































                                   D - 6








Named  association.   A  named  association specifies the association of an
item with one or more positions in a list, by naming the positions.

Object.  An object contains a value.  A program creates an object either by
elaborating an object declaration  or  by  evaluating  an  allocator.   The
declaration  or  allocator specifies a type for the object:  the object can
only contain values of that type.

Operation.  An operation is an elementary action  associated  with  one  or
more  types.   It  is  either implicitly declared by the declaration of the
type, or it is a subprogram that has a parameter or result of the type.

Operator.  An operator is an operation which has one or  two  operands.   A
unary  operator is written before an operand;  a binary operator is written
between two operands.  This notation is a special kind  of  function  call.
An  operator  can be declared as a function.  Many operators are implicitly
declared by the declaration of a type (for example, most type  declarations
imply the declaration of the equality operator for values of the type).

Overloading.   An  identifier  can  have  several alternative meanings at a
given point in the program text:  this property is called overloading.  For
example, an overloaded  enumeration  literal  can  be  an  identifier  that
appears in the definitions of two or more enumeration types.  The effective
meaning   of  an  overloaded  identifier  is  determined  by  the  context.
Subprograms, aggregates,  allocators,  and  string  literals  can  also  be
overloaded.

Package.   A  package specifies a group of logically related entities, such
as types, objects of those types, and subprograms with parameters of  those
types.   It  is  written  as a package declaration and a package body.  The
package declaration has a visible part, containing the declarations of  all
entities that can be explicitly used outside the package.  It may also have
a   private   part   containing   structural   details  that  complete  the
specification of the visible entities, but which are irrelevant to the user
of the package.  The package body contains implementations  of  subprograms
(and  possibly  tasks  as  other  packages) that have been specified in the
package declaration.  A package is one of the kinds of program unit.

Parameter.  A parameter is one of the  named  entities  associated  with  a
subprogram,  entry,  or  generic  unit,  and  used  to communicate with the
corresponding subprogram body, accept statement or generic body.  A  formal
parameter is an identifier used to denote the named entity within the body.
An   actual   parameter  is  the  particular  entity  associated  with  the
corresponding formal parameter by a subprogram call, entry call, or generic
instantiation.  The mode  of  a  formal  parameter  specifies  whether  the
associated  actual  parameter supplies a value for the formal parameter, or
the formal supplies a  value  for  the  actual  parameter,  or  both.   The
association of actual parameters with formal parameters can be specified by
named  associations,  by  positional  associations,  or by a combination of
these.

Parent type.  See derived type.

Positional association.  A positional association specifies the association
of an item with a position in a list, by using the  same  position  in  the


                                   D - 7








text to specify the item.

Pragma.  A pragma conveys information to the compiler.

Prefix.   A  prefix  is used as the first part of certain kinds of name.  A
prefix is either a function call or a name.

Private part.  See package.

Private type.  A private type is a type whose structure and set  of  values
are clearly defined, but not directly available to the user of the type.  A
private  type is known only by its discriminants (if any) and by the set of
operations defined for it.  A private type and  its  applicable  operations
are  defined in the visible part of a package, or in a generic formal part.
Assignment, equality, and inequality are also defined  for  private  types,
unless the private type is limited.









































                                   D - 8








Procedure.  See subprogram.

Program.   A  program  is composed of a number of compilation units, one of
which is a subprogram called the main program.  Execution  of  the  program
consists  of  execution  of  the main program, which may invoke subprograms
declared in the other compilation units of the program.

Program unit.  A program unit is  any  one  of  a  generic  unit,  package,
subprogram, or task unit.

Qualified  expression.  A qualified expression is an expression preceded by
an indication of its type or subtype.  Such qualification is used when,  in
its   absence,  the  expression  might  be  ambiguous  (for  example  as  a
consequence of overloading).

Raising an exception.  See exception.

Range.  A range is a contiguous set of values of a scalar type.  A range is
specified by giving the lower and upper bounds for the values.  A value  in
the range is said to belong to the range.

Range  constraint.   A  range  constraint  of a type specifies a range, and
thereby determines the subset of the values of the type that belong to  the
range.

Real  type.  A real type is a type whose values represent approximations to
the real numbers.  There are two kinds of real type:  fixed point types are
specified by absolute error bound;  floating point types are specified by a
relative error bound expressed as a number of significant  decimal  digits.

Record  type.   A  value  of a record type consists of components which are
usually of different types or subtypes.  For each  component  of  a  record
value  or  record  object,  the  definition of the record type specifies an
identifier that uniquely determines the component within the record.

Renaming declaration.  A renaming declaration declares another name for  an
entity.

Rendezvous.   A  rendezvous  is  the  interaction  that  occurs between two
parallel tasks when one task has called an entry of the other task,  and  a
corresponding  accept  statement  is  being  executed  by the other task on
behalf of the calling task.

Representation clause.  A representation clause directs the compiler in the
selection of the mapping of a type, an object, or a task onto  features  of
the   underlying   machine   that  executes  a  program.   In  some  cases,
representation clauses completely specify the  mapping;   in  other  cases,
they provide criteria for choosing a mapping.

Satisfy.  See constraint, subtype.

Scalar type.  An object or value of a scalar type does not have components.
A  scalar  type  is either a discrete type or a real type.  The values of a
scalar type are ordered.



                                   D - 9








Scope.  See declaration.

Selected component.  A selected component is a name consisting of a  prefix
and  of an identifier called the selector.  Selected components are used to
denote record components, entries, and objects designated by access values;
they are also used as expanded names.

Selector.  See selected component.

Simple name.  See declaration, name.















































                                  D - 10








Statement.  A statement specifies one  or  more  actions  to  be  performed
during the execution of a program.

Subcomponent.   A  subcomponent  is  either  a component, or a component of
another subcomponent.

Subprogram.  A subprogram is either a procedure or a function.  A procedure
specifies a sequence  of  actions  and  is  invoked  by  a  procedure  call
statement.   A  function specifies a sequence of actions and also returns a
value called the result, and so  a  function  call  is  an  expression.   A
subprogram  is  written  as  a  subprogram declaration, which specifies its
name, formal parameters, and (for a function) its result;  and a subprogram
body  which  specifies  the  sequence  of  actions.   The  subprogram  call
specifies  the  actual parameters that are to be associated with the formal
parameters.  A subprogram is one of the kinds of program unit.

Subtype.  A subtype of a type characterizes a subset of the values  of  the
type.  The subset is determined by a constraint on the type.  Each value in
the  set  of  values  of a subtype belongs to the subtype and satisfies the
constraint determining the subtype.

Subunit.  See body.

Task.  A task operates in parallel with other parts of the program.  It  is
written  as  a task specification (which specifies the name of the task and
the names and formal parameters of its entries),  and  a  task  body  which
defines its execution.  A task unit is one of the kinds of program unit.  A
task  type  is a type that permits the subsequent declaration of any number
of similar tasks of the type.  A value of a task type is said to  designate
a task.

Type.   A  type characterizes both a set of values, and a set of operations
applicable to those values.  A type definition is a language construct that
defines a type.  A particular type is either an access type, an array type,
a private type, a record type, a scalar type, or a task type.

Use clause.  A use clause achieves direct visibility of  declarations  that
appear in the visible parts of named packages.

Variable.  See object.

Variant  part.   A  variant  part  of a record specifies alternative record
components, depending on a discriminant of the record.  Each value  of  the
discriminant establishes a particular alternative of the variant part.

Visibility.   At  a  given  point  in a program text, the declaration of an
entity with a certain identifier is said to be visible if the entity is  an
acceptable  meaning for an occurrence at that point of the identifier.  The
declaration is visible by selection at the  place  of  the  selector  in  a
selected  component  or  at  the  place of the name in a named association.
Otherwise, the declaration is directly visible, that is, if the  identifier
alone has that meaning.

Visible part.  See package.



                                  D - 11








With clause.  See compilation unit.
























































                                  D - 12